home *** CD-ROM | disk | FTP | other *** search
/ Network PC / Network PC.iso / amiga utilities / communication / bbs / termv4.6 / extras / source / term-source.lha / FastMacros.c < prev    next >
Encoding:
C/C++ Source or Header  |  1996-03-18  |  6.0 KB  |  320 lines
  1. /*
  2. **    FastMacros.c
  3. **
  4. **    Fast! macros support routines
  5. **
  6. **    Copyright © 1990-1996 by Olaf `Olsen' Barthel
  7. **        All Rights Reserved
  8. */
  9.  
  10. #ifndef _GLOBAL_H
  11. #include "Global.h"
  12. #endif
  13.  
  14.     /* NewFastMacro(STRPTR Macro,STRPTR Code):
  15.      *
  16.      *    Create a new fast! macro node.
  17.      */
  18.  
  19. struct MacroNode *
  20. NewFastMacro(STRPTR Macro,STRPTR Code)
  21. {
  22.     struct MacroNode *Node;
  23.  
  24.     if(Node = (struct MacroNode *)AllocVecPooled(sizeof(struct MacroNode) + 21 + 257,MEMF_ANY|MEMF_CLEAR))
  25.     {
  26.         Node -> mn_Macro    = (STRPTR)(Node + 1);
  27.         Node -> mn_Code        = &Node -> mn_Macro[21];
  28.  
  29.         strcpy(Node -> mn_Macro,Macro);
  30.         strcpy(Node -> mn_Code ,Code);
  31.     }
  32.  
  33.     return(Node);
  34. }
  35.  
  36.     /* SaveFastMacros(STRPTR Name):
  37.      *
  38.      *    Save the fast! macro list to a file.
  39.      */
  40.  
  41. BOOL
  42. SaveFastMacros(STRPTR Name,struct List *FastMacroList)
  43. {
  44.     struct IFFHandle    *Handle;
  45.     BOOL             Success = FALSE;
  46.     LONG             Error;
  47.  
  48.     if(Handle = (struct IFFHandle *)AllocIFF())
  49.     {
  50.         if(Handle -> iff_Stream = Open(Name,MODE_NEWFILE))
  51.         {
  52.             InitIFFasDOS(Handle);
  53.  
  54.             if(!(Error = OpenIFF(Handle,IFFF_WRITE)))
  55.             {
  56.                 if(!(Error = PushChunk(Handle,ID_TERM,ID_CAT,IFFSIZE_UNKNOWN)))
  57.                 {
  58.                     if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  59.                     {
  60.                         if(!(Error = PushChunk(Handle,0,ID_VERS,IFFSIZE_UNKNOWN)))
  61.                         {
  62.                             struct TermInfo TermInfo;
  63.  
  64.                             TermInfo . Version    = CONFIG_FILE_VERSION;
  65.                             TermInfo . Revision    = CONFIG_FILE_REVISION;
  66.  
  67.                             if(WriteChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  68.                             {
  69.                                 if(Error = PopChunk(Handle))
  70.                                     Success = FALSE;
  71.                                 else
  72.                                 {
  73.                                     struct MacroNode *Node;
  74.  
  75.                                     Node = (struct MacroNode *)FastMacroList -> lh_Head;
  76.  
  77.                                     while(Node -> mn_Succ)
  78.                                     {
  79.                                         if(!(Error = PushChunk(Handle,ID_TERM,ID_FORM,IFFSIZE_UNKNOWN)))
  80.                                         {
  81.                                             if(!(Error = PushChunk(Handle,0,ID_FAST,IFFSIZE_UNKNOWN)))
  82.                                             {
  83.                                                 if(WriteChunkBytes(Handle,Node -> mn_Macro,20) != 20)
  84.                                                 {
  85.                                                     Error = IoErr();
  86.  
  87.                                                     Success = FALSE;
  88.  
  89.                                                     break;
  90.                                                 }
  91.                                                 else
  92.                                                 {
  93.                                                     if(WriteChunkBytes(Handle,Node -> mn_Code,256) != 256)
  94.                                                     {
  95.                                                         Error = IoErr();
  96.  
  97.                                                         Success = FALSE;
  98.  
  99.                                                         break;
  100.                                                     }
  101.                                                     else
  102.                                                     {
  103.                                                         if(Error = PopChunk(Handle))
  104.                                                         {
  105.                                                             Success = FALSE;
  106.  
  107.                                                             break;
  108.                                                         }
  109.                                                         else
  110.                                                             Success = TRUE;
  111.                                                     }
  112.                                                 }
  113.                                             }
  114.  
  115.                                             if(Success)
  116.                                             {
  117.                                                 if(Error = PopChunk(Handle))
  118.                                                 {
  119.                                                     Success = FALSE;
  120.  
  121.                                                     break;
  122.                                                 }
  123.                                             }
  124.                                         }
  125.  
  126.                                         Node = Node -> mn_Succ;
  127.                                     }
  128.                                 }
  129.                             }
  130.                             else
  131.                                 Error = IoErr();
  132.                         }
  133.  
  134.                         if(Success)
  135.                         {
  136.                             if(Error = PopChunk(Handle))
  137.                                 Success = FALSE;
  138.                         }
  139.                     }
  140.  
  141.                     if(Success)
  142.                     {
  143.                         if(Error = PopChunk(Handle))
  144.                             Success = FALSE;
  145.                     }
  146.                 }
  147.  
  148.                 CloseIFF(Handle);
  149.             }
  150.  
  151.             Close(Handle -> iff_Stream);
  152.         }
  153.         else
  154.             Error = IoErr();
  155.  
  156.         FreeIFF(Handle);
  157.     }
  158.     else
  159.         Error = ERR_NO_MEM;
  160.  
  161.     if(Success)
  162.         AddProtection(Name,FIBF_EXECUTE);
  163.     else
  164.         DeleteFile(Name);
  165.  
  166.     if(Error)
  167.         SetIoErr(Error);
  168.  
  169.     return(Success);
  170. }
  171.  
  172.     /* LoadFastMacros(STRPTR Name):
  173.      *
  174.      *    Restore the fast! macro list from a file.
  175.      */
  176.  
  177. BOOL
  178. LoadFastMacros(STRPTR Name,struct List *FastMacroList)
  179. {
  180.     STATIC ULONG Stops[6] =
  181.     {
  182.         ID_TERM,ID_VERS,
  183.         ID_TERM,ID_FAST,
  184.         ID_TERM,ID_WIND
  185.     };
  186.  
  187.     struct List __aligned     NewFastMacroList;
  188.     struct IFFHandle    *Handle;
  189.     BOOL             Success = FALSE;
  190.     struct MacroNode    *Node;
  191.     struct ContextNode    *Chunk;
  192.     struct IBox         SizeBox;
  193.     LONG             Error;
  194.  
  195.     NewList(&NewFastMacroList);
  196.  
  197.     if(Handle = AllocIFF())
  198.     {
  199.         if(Handle -> iff_Stream = Open(Name,MODE_OLDFILE))
  200.         {
  201.             InitIFFasDOS(Handle);
  202.  
  203.             if(!(Error = OpenIFF(Handle,IFFF_READ)))
  204.             {
  205.                 if(!(Error = StopChunks(Handle,(LONG *)Stops,3)))
  206.                 {
  207.                     LONG NewFastMacroCount = 0;
  208.  
  209.                     while(!ParseIFF(Handle,IFFPARSE_SCAN))
  210.                     {
  211.                         Chunk = CurrentChunk(Handle);
  212.  
  213.                         if(Chunk -> cn_ID == ID_VERS)
  214.                         {
  215.                             struct TermInfo TermInfo;
  216.  
  217.                             if(ReadChunkBytes(Handle,&TermInfo,sizeof(struct TermInfo)) == sizeof(struct TermInfo))
  218.                             {
  219.                                 if((TermInfo . Version > CONFIG_FILE_VERSION) || (TermInfo . Version == CONFIG_FILE_VERSION && TermInfo . Revision > CONFIG_FILE_REVISION) || (TermInfo . Version == 1 && TermInfo . Revision < 6))
  220.                                 {
  221.                                     Error = ERR_OUTDATED;
  222.  
  223.                                     break;
  224.                                 }
  225.                             }
  226.                             else
  227.                             {
  228.                                 Error = IoErr();
  229.  
  230.                                 break;
  231.                             }
  232.                         }
  233.  
  234.                         if(Chunk -> cn_ID == ID_WIND)
  235.                         {
  236.                             if(ReadChunkBytes(Handle,&SizeBox,sizeof(struct IBox)) == sizeof(struct IBox))
  237.                             {
  238.                                 FastWindowLeft        = SizeBox . Left;
  239.                                 FastWindowTop        = SizeBox . Top;
  240.                                 FastWindowHeight    = SizeBox . Height;
  241.                             }
  242.                             else
  243.                             {
  244.                                 Error = IoErr();
  245.  
  246.                                 break;
  247.                             }
  248.                         }
  249.  
  250.                         if(Chunk -> cn_ID == ID_FAST)
  251.                         {
  252.                             if(Node = NewFastMacro("",""))
  253.                             {
  254.                                 if(ReadChunkBytes(Handle,Node -> mn_Macro,20) == 20)
  255.                                 {
  256.                                     if(ReadChunkBytes(Handle,Node -> mn_Code,256) == 256)
  257.                                     {
  258.                                         AddTail(&NewFastMacroList,(struct Node *)Node);
  259.  
  260.                                         NewFastMacroCount++;
  261.  
  262.                                         Success = TRUE;
  263.                                     }
  264.                                     else
  265.                                     {
  266.                                         Error = IoErr();
  267.  
  268.                                         break;
  269.                                     }
  270.                                 }
  271.                                 else
  272.                                 {
  273.                                     Error = IoErr();
  274.  
  275.                                     break;
  276.                                 }
  277.                             }
  278.                             else
  279.                             {
  280.                                 Error = ERR_NO_MEM;
  281.  
  282.                                 break;
  283.                             }
  284.                         }
  285.                     }
  286.  
  287.                     if(Success)
  288.                     {
  289.                         if(NewFastMacroList . lh_Head -> ln_Succ)
  290.                         {
  291.                             FreeList(FastMacroList);
  292.  
  293.                             MoveList(&NewFastMacroList,FastMacroList);
  294.  
  295.                             FastMacroCount = NewFastMacroCount;
  296.                         }
  297.                     }
  298.                     else
  299.                         FreeList(&NewFastMacroList);
  300.                 }
  301.  
  302.                 CloseIFF(Handle);
  303.             }
  304.  
  305.             Close(Handle -> iff_Stream);
  306.         }
  307.         else
  308.             Error = IoErr();
  309.  
  310.         FreeIFF(Handle);
  311.     }
  312.     else
  313.         Error = ERR_NO_MEM;
  314.  
  315.     if(Error)
  316.         SetIoErr(Error);
  317.  
  318.     return(Success);
  319. }
  320.